home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / util / libs / muitoolkit_src.lha / muitoolkit_src / mt_funcs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-09-18  |  24.3 KB  |  995 lines
  1.  
  2. /*
  3. $Id: mt_funcs.c,v 1.6 1999/09/18 11:53:26 carlos Exp $.
  4. */
  5.  
  6. #include "mt_includes.h"
  7. #include "mt_private.h"
  8.  
  9. // v1
  10.  
  11.  
  12. //#define HighliteLabel(num)         TextObject, MUIA_Weight, 1, MUIA_Text_Contents, GS(num), MUIA_Text_PreParse, "\0333", End
  13. //#define HighliteLabelKey(num, key) TextObject, MUIA_Weight, 1, MUIA_Text_Contents, GS(num), MUIA_Text_PreParse, "\0333", MUIA_Text_HiChar, (char)key[0], End
  14. //#define LabelKey(num, key)         TextObject, MUIA_Weight, 1, MUIA_Text_PreParse, "\033r", MUIA_Text_Contents, GS(num), MUIA_Text_HiChar, (char)key[0], End
  15.  
  16. /// mt_Get
  17. ULONG SAVEDS ASM mt_Get( REG(a0) Object *obj, REG(d0) ULONG attr )
  18. {
  19. ULONG tmp;
  20.  
  21.     get( obj, attr, &tmp );
  22.     return( tmp );
  23. }
  24. //|
  25.  
  26. /// mt_ParseHotkey
  27.  
  28. char SAVEDS ASM mt_ParseHotkey( REG(a0) char *string )
  29. {
  30. char *Button;
  31. char Key = '\0';
  32.  
  33.     if(string)
  34.        {
  35.        Button = strchr(string, '_');
  36.  
  37.        if(Button)
  38.          Key = ToLower(Button[1]);
  39.  
  40.        }
  41.  
  42.     return(Key);
  43. }
  44. //|
  45.  
  46. /// mt_Label
  47. Object * SAVEDS ASM mt_Label( REG(a0) char *str )
  48. {
  49. // Etykieta
  50.  
  51.       return(MUI_MakeObject(MUIO_Label    ,str, MUIO_Label_DoubleFrame));
  52. }
  53. //|
  54. /// mt_PopButton
  55.  
  56. Object * SAVEDS ASM mt_PopButton( REG(d0) int img, REG(a0) char *key )
  57. {
  58. // PopButton z szortkatem
  59.  
  60.        Object *obj = MUI_MakeObject(MUIO_PopButton, img);
  61.  
  62.        if(obj)
  63.            {
  64.            set(obj, MUIA_CycleChain, TRUE);
  65.            set(obj, MUIA_ControlChar, mt_ParseHotkey(key));
  66.            }
  67.        return(obj);
  68. }
  69. //|
  70. /// mt_Checkmark
  71.  
  72. Object * SAVEDS ASM mt_Checkmark( REG(a0) char *str,
  73.                                   REG(d0) ULONG val,
  74.                                   REG(a1) char *help )
  75. {
  76. // Czekmark z szortkatem
  77.  
  78.         Object *obj = MUI_MakeObject(MUIO_Checkmark, str);
  79.         if(obj)
  80.            {
  81.            set(obj, MUIA_Selected, val );
  82.            set(obj, MUIA_CycleChain, TRUE);
  83.            set(obj, MUIA_ShortHelp, help );
  84.            }
  85.         return(obj);
  86. }
  87. //|
  88.  
  89. /// mt_Cycle
  90.  
  91. Object * SAVEDS ASM mt_Cycle( REG(a0) char **array,
  92.                               REG(a1) char *str,
  93.                               REG(d0) ULONG val,
  94.                               REG(a2) char *help )
  95. {
  96. // Sajkl z szortkatem
  97.  
  98.         Object *obj = MUI_MakeObject(MUIO_Cycle , str, array);
  99.         if(obj)
  100.            {
  101.            set(obj, MUIA_Cycle_Active, val );
  102.            set(obj, MUIA_CycleChain, TRUE);
  103.            set(obj, MUIA_ShortHelp, help );
  104.            }
  105.  
  106.         return(obj);
  107. }
  108. //|
  109. /// mt_CycleWeight
  110.  
  111. Object * SAVEDS ASM mt_CycleWeight( REG(a0) char **array,
  112.                                     REG(a1) char *str,
  113.                                     REG(d0) ULONG value,
  114.                                     REG(d1) long weight,
  115.                                     REG(a2) char *help )
  116. {
  117. // Sajkl z szortkatem
  118.  
  119.         Object *obj = mt_Cycle(array, str, value, help);
  120.         if(obj)
  121.            {
  122.            set(obj, MUIA_Weight, weight);
  123.            }
  124.  
  125.         return(obj);
  126. }
  127. //|
  128.  
  129. /// mt_Slider
  130.  
  131. Object * SAVEDS ASM mt_Slider( REG(d0) int min,
  132.                                REG(d1) int max,
  133.                                REG(d2) int level,
  134.                                REG(a0) char *str,
  135.                                REG(a1) char *help )
  136. {
  137. Object *obj = SliderObject, SliderFrame, SliderBack,
  138.                             MUIA_ControlChar, mt_ParseHotkey(str),
  139.                             MUIA_Slider_Min, min,
  140.                             MUIA_Slider_Max, max,
  141.                             MUIA_CycleChain, TRUE,
  142.                             MUIA_Slider_Level, level,
  143.                             MUIA_ShortHelp, help,
  144.                             End;
  145.  
  146.         return(obj);
  147. }
  148. //|
  149. /// mt_SliderFmt
  150.  
  151. Object * SAVEDS ASM mt_SliderFmt( REG(d0) int min,
  152.                                   REG(d1) int max,
  153.                                   REG(d2) int level,
  154.                                   REG(a0) char *str,
  155.                                   REG(a1) char *fmt,
  156.                                   REG(a2) char *help )
  157. {
  158. APTR obj = mt_Slider( min, max, level, str, help );
  159.  
  160.     if( obj )
  161.        {
  162.        set( obj, MUIA_Numeric_Format, fmt);
  163.        }
  164.  
  165.     return( obj );
  166. }
  167.  
  168. //|
  169.  
  170. /// mt_String
  171.  
  172. Object * SAVEDS ASM mt_String( REG(a0) char *str,
  173.                                REG(d0) int maxlen,
  174.                                REG(a1) char *label,
  175.                                REG(a2) char *help )
  176. {
  177.  
  178. Object *obj = StringObject, StringFrame,
  179.                             MUIA_ControlChar, mt_ParseHotkey( label ),
  180.                             MUIA_String_MaxLen, maxlen,
  181.                             MUIA_CycleChain, TRUE,
  182.                             MUIA_String_AdvanceOnCR, TRUE,
  183.                             MUIA_String_Contents, str,
  184.                             MUIA_ShortHelp, help,
  185.                             End;
  186.  
  187.         return(obj);
  188. }
  189. //|
  190. /// mt_StringSecret
  191.  
  192. Object * SAVEDS ASM mt_StringSecret( REG(a0) char *text,
  193.                                      REG(d0) int maxlen,
  194.                                      REG(a1) char *label,
  195.                                      REG(a2) char *help )
  196. {
  197.  
  198.     Object *obj = mt_String(text, maxlen, label, help );
  199.  
  200.     if( obj )
  201.        set(obj, MUIA_String_Secret, TRUE);
  202.  
  203.     return(obj);
  204.  
  205. }
  206. //|
  207. /// mt_StringAccept
  208. Object * SAVEDS ASM mt_StringAccept( REG(a0) char *text,
  209.                                      REG(d0) int maxlen,
  210.                                      REG(a1) char *label,
  211.                                      REG(a2) char *accept,
  212.                                      REG(a3) char *help
  213.                                      )
  214. {
  215.     Object *obj = mt_String(text, maxlen, label, help );
  216.  
  217.     if( obj )
  218.        set( obj, MUIA_String_Accept, accept );
  219.  
  220.     return(obj);
  221.  
  222. }
  223. //|
  224. /// mt_StringReject
  225. Object * SAVEDS ASM mt_StringReject( REG(a0) char *text,
  226.                                      REG(d0) int maxlen,
  227.                                      REG(a1) char *label,
  228.                                      REG(a2) char *reject,
  229.                                      REG(a3) char *help )
  230. {
  231.  
  232.     Object *obj = mt_String(text, maxlen, label, help );
  233.  
  234.     if( obj )
  235.        set( obj, MUIA_String_Reject, reject );
  236.  
  237.     return(obj);
  238.  
  239. }
  240. //|
  241.  
  242. /// mt_Button
  243.  
  244. Object * SAVEDS ASM mt_Button( REG(a0) char *str, REG(a1) char *help )
  245. {
  246. // buton textowy
  247.  
  248.     Object *obj = MUI_MakeObject( MUIO_Button, str );
  249.  
  250.     if(obj)
  251.        {
  252.        set( obj, MUIA_CycleChain, TRUE );
  253.        set( obj, MUIA_ShortHelp , help );
  254.        }
  255.  
  256.     return(obj);
  257. }
  258. //|
  259. /// mt_ButtonWeight
  260.  
  261. Object * SAVEDS ASM mt_ButtonWeight( REG(a0) char *str,
  262.                                      REG(d0) int weight,
  263.                                      REG(a1) char *help )
  264. {
  265. // buton textowy z podanâ wagâ
  266.  
  267.         Object *obj = mt_Button( str, help );
  268.  
  269.         if(obj)
  270.           {
  271.           set(obj, MUIA_Weight    , weight);
  272.           }
  273.         return(obj);
  274. }
  275. //|
  276. /// mt_ButtonToggle
  277.  
  278. Object * SAVEDS ASM mt_ButtonToggle( REG(a0) char *str,
  279.                                      REG(a1) char *help )
  280. {
  281. // buton textowy typu toggle
  282.  
  283.     Object *obj = mt_Button( str, help );
  284.  
  285.     if( obj )
  286.        {
  287.        set(obj, MUIA_InputMode, MUIV_InputMode_Toggle);
  288.        }
  289.  
  290.  
  291.     return(obj);
  292. }
  293. //|
  294.  
  295. /// mt_WinOpen
  296.  
  297. ULONG SAVEDS ASM mt_WinOpen( REG(a0) Object *win )
  298. {
  299.  
  300.     set( win, MUIA_Window_Open, TRUE );
  301.     return( mt_Get( win, MUIA_Window_Open ) );
  302.  
  303. }
  304. //|
  305. /// mt_WinAttach
  306.  
  307. ULONG SAVEDS ASM mt_WinAttach( REG(a0) Object *app, REG(a1) Object *win )
  308. {
  309.  
  310.     if( app && win )
  311.         {
  312.         DoMethod(app, OM_ADDMEMBER, win);
  313.         return( TRUE );
  314.         }
  315.     return( FALSE );
  316.  
  317. }
  318. //|
  319. /// mt_WinDetach
  320.  
  321. void SAVEDS ASM mt_WinDetach( REG(a0) Object *app, REG(a1) Object *win )
  322. {
  323.  
  324.     if( win && app )
  325.        {
  326.        DoMethod( app, OM_REMMEMBER, win );
  327.        MUI_DisposeObject( win );
  328.        }
  329.  
  330. }
  331. //|
  332.  
  333. /// mt_Text
  334.  
  335. Object * SAVEDS ASM mt_Text( REG(a0) char *text, REG(a1) char *preparse )
  336. {
  337.  
  338.     Object *obj = TextObject, TextFrame, TextBack,
  339.                   MUIA_Text_Contents, text,
  340.                   End;
  341.  
  342.  
  343.     if( preparse && obj )
  344.        set( obj, MUIA_Text_PreParse, preparse );
  345.  
  346.  
  347.  
  348.     return( obj );
  349. }
  350.  
  351. //|
  352.  
  353. /// mt_Radio
  354.  
  355. Object * SAVEDS ASM mt_Radio( REG(a0) char *array, REG(a1) char *label, REG(a2) char *help )
  356. {
  357.  
  358.     return( RadioObject,
  359.                 MUIA_Radio_Entries, array,
  360.                 MUIA_ControlChar, mt_ParseHotkey( label ),
  361.                 MUIA_CycleChain, TRUE,
  362.                 MUIA_ShortHelp, help,
  363.                 End
  364.            );
  365.  
  366. }
  367.  
  368. //|
  369. /// mt_Check
  370.  
  371. Object * SAVEDS ASM mt_Check( REG(a0) char *label,
  372.                               REG(d0) ULONG aligment,
  373.                               REG(d1) ULONG state,
  374.                               REG(a1) char *help )
  375.  
  376. {
  377. Object *obj;
  378.  
  379.     if( aligment == mt_Check_AlignRight )
  380.        {
  381.        obj = HGroup,
  382.                    MUIA_ShortHelp, help,
  383.  
  384.                    Child, HVSpace,
  385.                    Child, mt_Label( label ),
  386.                    Child, ImageObject,
  387.                                ImageButtonFrame,
  388.                                MUIA_InputMode     , MUIV_InputMode_Toggle,
  389.                                MUIA_Image_Spec    , MUII_CheckMark,
  390.                                MUIA_Image_FreeVert, TRUE,
  391.                                MUIA_Selected      , state,
  392.                                MUIA_Background    , MUII_ButtonBack,
  393.                                MUIA_ShowSelState  , FALSE,
  394.                                MUIA_ControlChar   , mt_ParseHotkey( label ),
  395.                                MUIA_CycleChain    , TRUE,
  396.                                End,
  397.                    End;
  398.        }
  399.     else
  400.        {
  401.        obj = HGroup,
  402.                    MUIA_ShortHelp, help,
  403.  
  404.                    Child, ImageObject,
  405.                                ImageButtonFrame,
  406.                                MUIA_InputMode     , MUIV_InputMode_Toggle,
  407.                                MUIA_Image_Spec    , MUII_CheckMark,
  408.                                MUIA_Image_FreeVert, TRUE,
  409.                                MUIA_Selected      , state,
  410.                                MUIA_Background    , MUII_ButtonBack,
  411.                                MUIA_ShowSelState  , FALSE,
  412.                                MUIA_ControlChar   , mt_ParseHotkey( label ),
  413.                                End,
  414.                    Child, mt_Label( label ),
  415.                    Child, HVSpace,
  416.                    End;
  417.        }
  418.  
  419.  
  420.     return( obj );
  421. }
  422.  
  423. //|
  424.  
  425. /// mt_GetStringA
  426.  
  427. /*
  428. ** Requester dot. wartoôci numerycznych
  429. ** Zwraca BOOL w zaleûnoôci czy uûytkownik
  430. ** wybraî OK czy nie. Wynik umieszczany
  431. ** jest w odpowiednim polu struktury StringRequest
  432. ** w zaleûnoôci od typu reqestera
  433. */
  434.  
  435.  
  436. ULONG SAVEDS ASM mt_GetStringA( REG(a0) Object *app,
  437.                                 REG(a1) char   *buffer,
  438.                                 REG(d0) ULONG   buf_len,
  439.                                 REG(a2) struct TagItem *tagitem)
  440.  
  441. {
  442. Object *Window      = NULL,     /* STRING REQUESTER */
  443.         *GR_Group,
  444.         *ST_String,
  445.         *BT_Ok,
  446.         *BT_Cancel;
  447.  
  448. #define MSG_STRREQ_WINTITLE "String request"
  449. #define MSG_STRREQ_TITLE    "Enter string"
  450. #define MSG_STRREQ_OK       "_Ok"
  451. #define MSG_STRREQ_CANCEL   "_Cancel"
  452.  
  453. char *WindowTitle = MSG_STRREQ_WINTITLE;
  454. char *GroupTitle  = MSG_STRREQ_TITLE;
  455. char *Contents    = NULL;
  456. char *Ok          = MSG_STRREQ_OK;
  457. char *Cancel      = MSG_STRREQ_CANCEL;
  458. char *Info        = FALSE;
  459. char *StringHelp  = NULL;
  460.  
  461. ULONG Secret      = FALSE;
  462. ULONG NoEmpty     = FALSE;
  463.  
  464. struct TagItem *tags, *tag;
  465.  
  466. char  result  = FALSE;
  467.  
  468.  
  469.     if( !app )
  470.        return( FALSE );
  471.  
  472.  
  473.     for(tags=tagitem; tag = NextTagItem( &tags ); )
  474.        {
  475.        switch(tag->ti_Tag)
  476.            {
  477.            case mt_StrReq_WinTitle:
  478.                WindowTitle = (char *)tag->ti_Data;
  479.                break;
  480.  
  481.            case mt_StrReq_Contents:
  482.                Contents = (char *)tag->ti_Data;
  483.                break;
  484.  
  485.            case mt_StrReq_Ok:
  486.                Ok = (char *)tag->ti_Data;
  487.                break;
  488.  
  489.            case mt_StrReq_Cancel:
  490.                Cancel = (char *)tag->ti_Data;
  491.                break;
  492.  
  493.            case mt_StrReq_Secret:
  494.                Secret = tag->ti_Data;
  495.                break;
  496.  
  497.            case mt_StrReq_NoEmpty:
  498.                NoEmpty = tag->ti_Data;
  499.                break;
  500.  
  501.            case mt_StrReq_GroupTitle:
  502.                GroupTitle = (char *)tag->ti_Data;
  503.                break;
  504.  
  505.            case mt_StrReq_Info:
  506.                Info = (char *)tag->ti_Data;
  507.                break;
  508.  
  509.            case mt_StrReq_StringHelp:
  510.                StringHelp = (char *)tag->ti_Data;
  511.                break;
  512.  
  513.            }
  514.        }
  515.  
  516.  
  517. ///   Create window
  518.  
  519.        Window = WindowObject,
  520.                         MUIA_Window_ID         , ID_MT_STRREQ,
  521. //                        MUIA_Window_ScreenTitle, ScreenTitle,
  522.                         MUIA_Window_Title      , WindowTitle,
  523.                         WindowContents,
  524.                            VGroup,
  525.  
  526.                            Child, GR_Group = VGroup,
  527.                                   GroupFrameT( GroupTitle ),
  528.                                   Child, ST_String = mt_String( Contents, buf_len, NULL, StringHelp ),
  529.                                   End,
  530.  
  531.                            Child, HGroup,
  532.                                   MUIA_Group_SameSize, TRUE,
  533.                                   Child, BT_Ok     = mt_Button( Ok, NULL ),
  534.                                   Child, BT_Cancel = mt_Button( Cancel, NULL ),
  535.                                   End,
  536.  
  537.                            End,
  538.                       End;
  539.  
  540.  
  541.        if( !Window )
  542.            return( FALSE );
  543.  
  544.  
  545.        if( Info )
  546.            {
  547.            Object *FT_Info = FloattextObject,
  548.                                TextFrame, TextBack,
  549.                                MUIA_Floattext_Text, Info,
  550.                                End;
  551.  
  552.            if( FT_Info )
  553.                {
  554.                if (DoMethod( GR_Group, MUIM_Group_InitChange ))
  555.                    {
  556.                    DoMethod( GR_Group, OM_REMMEMBER, ST_String );
  557.  
  558.                    DoMethod( GR_Group, OM_ADDMEMBER, FT_Info );
  559.                    DoMethod( GR_Group, OM_ADDMEMBER, ST_String );
  560.  
  561.                    DoMethod( GR_Group, MUIM_Group_ExitChange );
  562.                    }
  563.                }
  564.  
  565.            }
  566. //|
  567.  
  568.  
  569.     mt_Sleep( TRUE );
  570.  
  571.  
  572.     // notification
  573.     DoMethod(Window   , MUIM_Notify, MUIA_Window_CloseRequest, TRUE ,MUIV_Notify_Application, 2 ,MUIM_Application_ReturnID, ID_CANCEL);
  574.     DoMethod(BT_Ok    , MUIM_Notify, MUIA_Pressed, FALSE, MUIV_Notify_Application, 2 ,MUIM_Application_ReturnID, ID_OK);
  575.     DoMethod(BT_Cancel, MUIM_Notify, MUIA_Pressed, FALSE, MUIV_Notify_Application, 2 ,MUIM_Application_ReturnID, ID_CANCEL);
  576.  
  577.  
  578.     // setting up...
  579.     if( WindowTitle )
  580.        set( Window, MUIA_Window_Title, WindowTitle );
  581.  
  582.     if( Contents )
  583.         setstring( ST_String, Contents );
  584.  
  585.     set( Window, MUIA_Window_ActiveObject, ST_String );
  586.  
  587. /*
  588.     if( NoEmpty )
  589.        set( BT_Ok, MUIA_Disabled,  (*(char *)getstring( ST_String ) == 0 ) );
  590. */
  591.  
  592.  
  593.     mt_WinAttach( app, Window );
  594.  
  595.  
  596.     // let's go
  597.  
  598.     {
  599.     char  running = TRUE;
  600.     ULONG signal  = 0;
  601.  
  602.  
  603.     if(  mt_WinOpen( Window ) )
  604.        {
  605.        while(running)
  606.           {
  607.           switch (DoMethod(app, MUIM_Application_Input, &signal))
  608.             {
  609.             case ID_OK:
  610.                {
  611.                char *buf = getstring( ST_String );
  612.  
  613.                if( NoEmpty && buf[0] == 0 )
  614.                    {
  615.                    DisplayBeep(0);
  616.                    set( Window, MUIA_Window_ActiveObject, ST_String );
  617.                    break;
  618.                    }
  619.  
  620.                strncpy(buffer, buf, buf_len);
  621.                result = TRUE;
  622.                running = FALSE;
  623.                }
  624.                break;
  625.  
  626.             case ID_CANCEL:
  627.                running = FALSE;
  628.                break;
  629.  
  630.             }
  631.           if(running && signal) Wait(signal);
  632.           }
  633.  
  634.        mt_WinClose( Window );
  635.        }
  636.     else
  637.        {
  638.        DisplayBeep(0);
  639. //       MUI_Request(app, MainWindow, 0, TITLE, MSG_OK, MSG_ERR_WINDOW);
  640.        }
  641.     }
  642.  
  643.  
  644.     mt_WinDetach( app, Window );
  645.  
  646.     mt_Sleep( FALSE );
  647.  
  648.     return(result);
  649.  
  650.  
  651. }
  652. //|
  653. /// mt_GetIntegerA
  654.  
  655. /*
  656. ** Requester dot. wartoôci numerycznych
  657. ** Zwraca BOOL w zaleûnoôci czy uûytkownik
  658. ** wybraî OK czy nie. Wynik umieszczany
  659. ** jest w odpowiednim polu struktury StringRequest
  660. ** w zaleûnoôci od typu reqestera
  661. */
  662.  
  663.  
  664. ULONG SAVEDS ASM mt_GetIntegerA( REG(a0) Object *app,
  665.                                  REG(a1) LONG   *value,
  666.                                  REG(a2) struct TagItem *tagitem)
  667.  
  668. {
  669. Object *Window      = NULL,     /* STRING REQUESTER */
  670.        *GR_Group,
  671.        *ST_String,
  672.        *BT_Ok,
  673.        *BT_Cancel,
  674.  
  675.        *GR_Bound = NULL;
  676.  
  677.  
  678. #define MSG_INTREQ_WINTITLE "Integer request"
  679. #define MSG_INTREQ_TITLE    "Enter value"
  680. #define MSG_INTREQ_OK       "_Ok"
  681. #define MSG_INTREQ_CANCEL   "_Cancel"
  682.  
  683. #define INTREQ_SIZE 30
  684.  
  685. char Contents[ INTREQ_SIZE ] = "";
  686. char *WindowTitle = MSG_INTREQ_WINTITLE;
  687. char *GroupTitle  = MSG_INTREQ_TITLE;
  688. char *Ok          = MSG_INTREQ_OK;
  689. char *Cancel      = MSG_INTREQ_CANCEL;
  690. char *Info        = NULL;
  691. char *StringHelp  = NULL;
  692.  
  693. char MinBound = FALSE;
  694. char MaxBound = FALSE;
  695. LONG MinVal, MaxVal;
  696.  
  697. struct TagItem *tags, *tag;
  698.  
  699. char  result  = FALSE;
  700.  
  701.  
  702.     if( !app )
  703.        return( FALSE );
  704.  
  705.  
  706.     for(tags=tagitem; tag = NextTagItem( &tags ); )
  707.        {
  708.        switch(tag->ti_Tag)
  709.            {
  710.            case mt_IntReq_WinTitle:
  711.                WindowTitle = (char *)tag->ti_Data;
  712.                break;
  713.  
  714.            case mt_IntReq_Value:
  715.                sprintf(Contents, "%ld", (LONG)tag->ti_Data );
  716.                break;
  717.  
  718.            case mt_IntReq_Ok:
  719.                Ok = (char *)tag->ti_Data;
  720.                break;
  721.  
  722.            case mt_IntReq_Cancel:
  723.                Cancel = (char *)tag->ti_Data;
  724.                break;
  725.  
  726.            case mt_IntReq_GroupTitle:
  727.                GroupTitle = (char *)tag->ti_Data;
  728.                break;    
  729.  
  730.            case mt_IntReq_Min:
  731.                MinVal   = (LONG)tag->ti_Data;
  732.                MinBound = TRUE;
  733.                break;
  734.  
  735.            case mt_IntReq_Max:
  736.                MaxVal   = (LONG)tag->ti_Data;
  737.                MaxBound = TRUE;
  738.                break;
  739.  
  740.            case mt_IntReq_Info:
  741.                Info = (char *)tag->ti_Data;
  742.                break;
  743.  
  744.            case mt_IntReq_StringHelp:
  745.                StringHelp = (char *)tag->ti_Data;
  746.                break;
  747.            }
  748.        }
  749.  
  750.  
  751.     // some anti-dummies checks...
  752.  
  753.     if( MinBound && MaxBound )
  754.        if( MinVal > MaxVal )
  755.            {
  756.            LONG tmp = MinVal;
  757.  
  758.            MinVal = MaxVal;
  759.            MaxVal = tmp;
  760.            }
  761.  
  762.  
  763. ///   Create window
  764.         Window = WindowObject,
  765.                         MUIA_Window_ID         , ID_MT_INTREQ,
  766. //                        MUIA_Window_ScreenTitle, ScreenTitle,
  767.                         MUIA_Window_Title      , WindowTitle,
  768.                         WindowContents,
  769.                            VGroup,
  770.  
  771.                            Child, GR_Group = VGroup,
  772.                                   GroupFrameT( GroupTitle ),
  773.                                   Child, ST_String = mt_StringAccept( Contents, INTREQ_SIZE, NULL, "-0123456789", StringHelp ),
  774.                                   End,
  775.  
  776.                            Child, HGroup,
  777.                                   MUIA_Group_SameSize, TRUE,
  778.                                   Child, BT_Ok     = mt_Button( Ok, NULL ),
  779.                                   Child, BT_Cancel = mt_Button( Cancel, NULL ),
  780.                                   End,
  781.  
  782.                            End,
  783.                       End;
  784.  
  785.     if( !Window )
  786.        return(FALSE);
  787.  
  788.  
  789.     if( Info )
  790.            {
  791.            Object *FT_Info = FloattextObject,
  792.                                TextFrame, TextBack,
  793.                                MUIA_Floattext_Text, Info,
  794.                                End;
  795.  
  796.            if( FT_Info )
  797.                {
  798.                if (DoMethod( GR_Group, MUIM_Group_InitChange ))
  799.                    {
  800.                    DoMethod( GR_Group, OM_REMMEMBER, ST_String );
  801.  
  802.                    DoMethod( GR_Group, OM_ADDMEMBER, FT_Info );
  803.                    DoMethod( GR_Group, OM_ADDMEMBER, ST_String );
  804.  
  805.                    DoMethod( GR_Group, MUIM_Group_ExitChange );
  806.                    }
  807.                }
  808.  
  809.            }
  810.  
  811. //|
  812.  
  813.     // any bounds?
  814.  
  815.     if( MinBound || MaxBound )
  816.        {
  817.        GR_Bound = HGroup, MUIA_Group_SameSize, TRUE, End;
  818.  
  819.        if( GR_Bound )
  820.            {
  821.            char tmp[60];
  822.  
  823.            if( MinBound )
  824.                {
  825.                sprintf( tmp, "\033bMin:\033n %ld", MinVal );
  826.                DoMethod( GR_Bound, OM_ADDMEMBER, mt_Text( tmp, "\033c" ) );
  827.                }
  828.  
  829.            if( MaxBound )
  830.                {
  831.                sprintf( tmp, "\033bMax:\033n %ld", MaxVal );
  832.                DoMethod( GR_Bound, OM_ADDMEMBER, mt_Text( tmp, "\033c" ) );
  833.                }
  834.  
  835.            DoMethod( GR_Group, OM_ADDMEMBER, GR_Bound );
  836.            }
  837.        else
  838.            {
  839.            MUI_DisposeObject( Window );
  840.            return( FALSE );
  841.            }
  842.        }
  843.  
  844.     mt_Sleep( TRUE );
  845.  
  846.  
  847.     // notification
  848.     DoMethod(Window   , MUIM_Notify, MUIA_Window_CloseRequest, TRUE ,MUIV_Notify_Application, 2 ,MUIM_Application_ReturnID, ID_CANCEL);
  849.     DoMethod(BT_Ok    , MUIM_Notify, MUIA_Pressed, FALSE, MUIV_Notify_Application, 2 ,MUIM_Application_ReturnID, ID_OK);
  850.     DoMethod(BT_Cancel, MUIM_Notify, MUIA_Pressed, FALSE, MUIV_Notify_Application, 2 ,MUIM_Application_ReturnID, ID_CANCEL);
  851.  
  852.  
  853.     // setting up...
  854.     if( WindowTitle )
  855.        set( Window, MUIA_Window_Title, WindowTitle );
  856.  
  857.     if( Contents )
  858.         setstring( ST_String, Contents );
  859.  
  860.     set( Window, MUIA_Window_ActiveObject, ST_String );
  861.  
  862. /*
  863.     if( NoEmpty )
  864.        set( BT_Ok, MUIA_Disabled,  (*(char *)getstring( ST_String ) == 0 ) );
  865. */
  866.  
  867.  
  868.     mt_WinAttach( app, Window );
  869.  
  870.  
  871.     // let's go
  872.  
  873.     {
  874.     char  running = TRUE;
  875.     ULONG signal  = 0;
  876.  
  877.  
  878.     if(  mt_WinOpen( Window ) )
  879.        {
  880.        while(running)
  881.           {
  882.           switch (DoMethod(app, MUIM_Application_Input, &signal))
  883.             {
  884.             case ID_OK:
  885.                {
  886.                char *buf = getstring( ST_String );
  887.                LONG val  = getnumstring( ST_String );
  888.  
  889.                if( buf[0] == 0 )
  890.                    {
  891.                    result = running = FALSE;
  892.                    break;
  893.                    }
  894.  
  895.  
  896.                if( MinBound )
  897.                    {
  898.                    if( val < MinVal )
  899.                        {
  900.                        DisplayBeep(0);
  901.                        set( Window, MUIA_Window_ActiveObject, ST_String );
  902.                        break;
  903.                        }
  904.                    }
  905.  
  906.                if( MaxBound )
  907.                    {
  908.                    if( val > MaxVal )
  909.                        {
  910.                        DisplayBeep(0);
  911.                        set( Window, MUIA_Window_ActiveObject, ST_String );
  912.                        break;
  913.                        }
  914.                    }
  915.  
  916.                *value = val;
  917.                result = TRUE;
  918.                running = FALSE;
  919.                }
  920.                break;
  921.  
  922.             case ID_CANCEL:
  923.                running = FALSE;
  924.                break;
  925.  
  926.             }
  927.           if(running && signal) Wait(signal);
  928.           }
  929.  
  930.        mt_WinClose( Window );
  931.        }
  932.     else
  933.        {
  934.        DisplayBeep(0);
  935. //       MUI_Request(app, MainWindow, 0, TITLE, MSG_OK, MSG_ERR_WINDOW);
  936.        }
  937.     }
  938.  
  939.  
  940.     mt_WinDetach( app, Window );
  941.  
  942.     mt_Sleep( FALSE );
  943.  
  944.     return(result);
  945.  
  946.  
  947. }
  948. //|
  949.  
  950.  
  951. /*
  952. /// tmp
  953. /*
  954. Object *TextButton2(char *str, char *str2)
  955. {
  956.         Object *obj = MUI_NewObject(MUIC_Text,
  957.                                 ButtonFrame,
  958.                                 MUIA_Text_PreParse, "\33c",
  959.                                 MUIA_Text_Contents, str,
  960.                                 MUIA_CycleChain   , TRUE,
  961.                                 MUIA_InputMode    , MUIV_InputMode_RelVerify,
  962.                                 MUIA_Background   , MUII_ButtonBack,
  963.                                 MUIA_Text_HiChar  , (ULONG)( str2 )[0],
  964.                                 MUIA_ControlChar  , (ULONG)( str2 )[0],
  965.                                 TAG_DONE
  966.                                 );
  967.         return(obj);
  968. }
  969. */
  970. /*
  971. Object *SizedButton(char *str)
  972. {
  973.     Object *obj = VGroup,
  974.                   ButtonFrame,
  975.                   MUIA_ControlChar  , mt_ParseHotkey(str),
  976.                   MUIA_Background   , MUII_ButtonBack,
  977.                   MUIA_InputMode    , MUIV_InputMode_RelVerify,
  978.                   MUIA_CycleChain   , TRUE,
  979.                   Child, HVSpace,
  980.                   Child, HGroup,
  981.                          Child, HVSpace,
  982.                          Child, MakeLabel2(str),
  983.                          Child, HVSpace,
  984.                          End,
  985.  
  986.                   Child, HVSpace,
  987.                   End;
  988.  
  989.     return(obj);
  990. }
  991. */
  992. //|
  993. */
  994.  
  995.